home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / text / misc / MSWordView_src.lha / mswordview / hyperlink.c < prev    next >
C/C++ Source or Header  |  1998-12-14  |  5KB  |  219 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <ctype.h>
  4. #include <string.h>
  5. #include <time.h>
  6. #include "config.h"
  7. #include "mswordview.h"
  8.  
  9. extern FILE *erroroutput;
  10. extern FILE *outputfile;
  11.  
  12. extern long int cp;
  13. extern long int realcp;
  14.  
  15. /*this sucks in the bookmark names which will be used for internal hyperlink jumps*/
  16. void decode_bookmarks(FILE *mainfd,FILE *tablefd,textportions *portions)
  17.     {
  18.     U32 fcSttbfbkmk,lcbSttbfbkmk;
  19.     U32 fcPlcfbkf,lcbPlcfbkf;
  20.     U32 fcPlcfbkl,lcbPlcfbkl;
  21.  
  22.     fseek(mainfd,0x0142,SEEK_SET);
  23.     fcSttbfbkmk = read_32ubit(mainfd);
  24.     lcbSttbfbkmk = read_32ubit(mainfd);
  25.     error(erroroutput,"table offset for boomarks is %x %d\n",fcSttbfbkmk,lcbSttbfbkmk);
  26.     
  27.     extract_sttbf(&(portions->bookmarks),tablefd,fcSttbfbkmk,lcbSttbfbkmk);
  28.  
  29.     fcPlcfbkf=read_32ubit(mainfd);
  30.     lcbPlcfbkf=read_32ubit(mainfd);
  31.     fcPlcfbkl=read_32ubit(mainfd);
  32.     lcbPlcfbkl=read_32ubit(mainfd);
  33.  
  34.     extract_bookm_limits(&( portions->l_bookmarks),tablefd,fcPlcfbkf,lcbPlcfbkf,fcPlcfbkl,lcbPlcfbkl);
  35.     }
  36.  
  37. /*
  38. this attempts to parse the HYPERLINK field that ms uses to encode
  39. hyperlink information
  40. */
  41. U16 *decode_hyperlink(int letter, long int *swallowcp1, long int *swallowcp2, U16 **deleteme)
  42.     {
  43.     /* a little state machine then */
  44.     /* 
  45.     1) a hyperlink may or may not start with a space, 
  46.     2) then a word HYPERLINK, though sometimes in another language i believe, 
  47.     3) then another space, 
  48.     4) after this usually theres a link 
  49.     5) followed by an optional final space and an optional 0x01
  50.     but 4 might start with a space then \l then a space then a string then a
  51.     space.
  52.     --
  53.     so we need to get the full len of what we're dealing with, read it all in
  54.     then strip out the HYPERLINK portion, scan for a " \l ", remove it, also
  55.     remove any "0x01" and output the remainder.
  56.  
  57.     as this eats the 0x14 we have to manually do the > in the calling function.
  58.     */
  59.  
  60.     /*if these are zero initialize them from the input*/
  61.     static long int from=-1;
  62.     static long to=-1;
  63.     static int no;
  64.     static U16 *array;
  65.     U16 *begin,*begin2;
  66.     static int state;
  67.     
  68.  
  69.     error(erroroutput,"incoming, letter is %c %x\n",letter,letter);
  70.  
  71.     if (from == -1)
  72.         {
  73.         from = *swallowcp1;
  74.         to = *swallowcp2;
  75.         array = (U16 *) malloc (sizeof(U16) * ((to+1)-from));
  76.         if (array==NULL)
  77.             {
  78.             error(erroroutput,"no mem for hyperlink\n");
  79.             exit(-1);
  80.             }
  81.         }
  82.  
  83.     switch(state)
  84.         {
  85.         case 0:
  86.             state=1;
  87.             break;
  88.         case 1:    
  89.             if (letter == 0x20)
  90.                 state=2;
  91.             break;
  92.         case 2:
  93.             if (letter != 0x01)
  94.                 array[no++] = letter;
  95.             else 
  96.                 {
  97.                 state=3;
  98.                 if (letter != 0x14)
  99.                     break;    
  100.                 else
  101.                     no--;
  102.                 }
  103.             /*let 0x14 fall into the next state*/
  104.         case 3:    
  105.             if ((letter == 0x14) || (letter == 0x15))
  106.                 {
  107.                 state=0;
  108.                 no--;
  109.                 if (array[no] == ' ')
  110.                     no--;
  111.                 array[no+1] = '\0';
  112.                 /*
  113.                 error(erroroutput,"the current string is <!--%s-->\n",array);
  114.                 */
  115.                 begin = array;
  116.                 /*analyse this string looking for a backslash l, which for now
  117.                 we will assume is always found as a space a blackslask an l and a space*/
  118.                 if (array[0] == ' ') 
  119.                     if (array[1] == '\\')
  120.                         if (array[2] == 'l')
  121.                             if (array[3] == ' ')
  122.                                 {
  123.                                 begin = array+3;
  124.                                 if (array[4] == '\"')
  125.                                     {
  126.                                     *begin='\"';
  127.                                     *(begin+1)='#';
  128.                                     }
  129.                                 else
  130.                                     *begin='#';
  131.                                 }
  132.                 error(erroroutput,"the current string is <!--");
  133.                 begin2 = begin;
  134.                 while (*begin2 != '\0')
  135.                     error(erroroutput,"%c",*begin2++);
  136.                 error(erroroutput,"-->\n");
  137.                     
  138.                 from=-1;
  139.                 to=-1;
  140.                 no=0;
  141.                 *deleteme = array;
  142.                 return(begin);
  143.                 }
  144.             break;    
  145.         }
  146.  
  147.     return(NULL);
  148.     }
  149.  
  150. /*
  151. this attempts to parse the REF field that ms uses to encode
  152. crosslink information
  153. */
  154. U16 *decode_crosslink(int letter,long int *swallowcp1, long int *swallowcp2)
  155.     {
  156.     /* a little state machine then */
  157.     /* 
  158.     1) a reference may or may not start with a space, 
  159.     2) then a word PAGEREF, though ill not assume this
  160.     3) then another space
  161.     4) after this theres the name of the bookmark
  162.     5) followed by a space 
  163.     6) there may be a few flags here e.g [\h] [\p] followed by 
  164.     a space.
  165.     7) probably terminating 0x01
  166.     --
  167.     so we need to get the full len of what we're dealing with, read it all in
  168.     then strip out the HYPERLINK portion, scan for a " \l ", remove it, also
  169.     remove any "0x01" and output the remainder.
  170.  
  171.     as this eats the 0x14 we have to manually do the > in the calling function.
  172.     */
  173.  
  174.     static int no=0;
  175.     static int state;
  176.     
  177.     static long int from=-1;
  178.     static long int to=-1;
  179.     static U16 *array;
  180.  
  181.     if (from == -1)
  182.         {
  183.         from = *swallowcp1;
  184.         to = *swallowcp2;
  185.         error(erroroutput,"a mallocing %d\n",(to+1)-from);
  186.         array = (U16 *) malloc (sizeof(U16) * ((to+1)-from));
  187.         if (array==NULL)
  188.             {
  189.             error(erroroutput,"no mem for hyperlink\n");
  190.             exit(-1);
  191.             }
  192.         }
  193.  
  194.     switch(state)
  195.         {
  196.         case 0:
  197.             state=1;
  198.             break;
  199.         case 1:
  200.             if (letter == 0x20) 
  201.                 state=2;
  202.             break;
  203.         case 2:
  204.             if ((letter != 0x20) && (letter != 0x01) && (letter != 0x14))
  205.                 array[no++] = letter;
  206.             else 
  207.                 {
  208.                 state=0;
  209.                 from=-1;
  210.                 to=-1;
  211.                 array[no] = '\0';
  212.                 no=0;
  213.                 return(array);
  214.                 }
  215.             break;
  216.         }
  217.     return(NULL);
  218.     }
  219.